What is klona?
The klona npm package is a JavaScript utility for deep cloning objects. It allows developers to create a deep copy of an object, ensuring that changes to the new object do not affect the original object. This is particularly useful when working with complex data structures or when you need to ensure data immutability.
What are klona's main functionalities?
Deep cloning of objects
This feature allows you to create a deep clone of an object, which means that nested objects are also cloned, and changes to the cloned object do not affect the original object.
{"const klona = require('klona');\nconst original = { a: 1, b: { c: 2 } };\nconst copy = klona(original);\ncopy.b.c = 3;\nconsole.log(original.b.c); // 2\nconsole.log(copy.b.c); // 3"}
Deep cloning of arrays
Similar to object cloning, klona can also deep clone arrays, including nested arrays, ensuring that modifications to the cloned array do not affect the original array.
{"const klona = require('klona');\nconst original = [1, [2, 3], [4, 5]];\nconst copy = klona(original);\ncopy[1][0] = 'changed';\nconsole.log(original[1][0]); // 2\nconsole.log(copy[1][0]); // 'changed'"}
Cloning class instances
klona is capable of cloning instances of classes, allowing you to duplicate an instance and modify the copy without affecting the original instance.
{"const klona = require('klona');\nclass Example {\n constructor(value) {\n this.value = value;\n }\n}\nconst original = new Example(1);\nconst copy = klona(original);\ncopy.value = 2;\nconsole.log(original.value); // 1\nconsole.log(copy.value); // 2"}
Other packages similar to klona
lodash
Lodash is a popular utility library that includes a `cloneDeep` function for deep cloning objects. It is more feature-rich than klona but also larger in size, which might be a consideration for projects where bundle size is a concern.
deep-copy
deep-copy is another npm package that provides deep cloning functionality. It offers similar capabilities to klona but may have different performance characteristics or API nuances.
rfdc
rfdc (Really Fast Deep Clone) is a package that focuses on performance for deep cloning objects and arrays. It claims to be faster than other deep cloning methods, which might make it a preferred choice for performance-critical applications.
A tiny (423B) and fast utility to "deep clone" Objects, Arrays, Dates, RegExps, and more!
Features
- Super tiny and performant
- Deep clone / recursive copies
- Safely handles complex data types
Array, Date, Map, Object, RegExp, Set, TypedArray
Unlike a "shallow copy" (eg, Object.assign
), a "deep clone" recursively traverses a source input and copies its values — instead of references to its values — into a new instance of that input. The result is a structurally equivalent clone that operates independently of the original source and controls its own values.
Additionally, this module is delivered as:
Why "klona"? It's "clone" in Swedish.
What's with the sheep? Dolly.
Install
$ npm install --save klona
Usage
import klona from 'klona';
const input = {
foo: 1,
bar: {
baz: 2,
bat: {
hello: 'world'
}
}
};
const output = klona(input);
assert.deepStrictEqual(input, output);
output.bar.bat.hola = 'mundo';
output.bar.baz = 99;
console.log(
JSON.stringify(input, null, 2)
);
API
klona(input)
Returns: typeof input
Returns a deep copy/clone of the input.
Benchmarks
via Node.js v10.13.0
Load times:
fast-clone 0.884ms
lodash/clonedeep 27.716ms
rfdc 0.782ms
clone-deep 4.023ms
deep-copy 0.513ms
klona 0.333ms
Validation:
✘ JSON.stringify (FAILED @ "initial copy")
✘ fast-clone (FAILED @ "initial copy")
✔ lodash
✘ rfdc (FAILED @ "initial copy")
✔ clone-deep
✘ deep-copy (FAILED @ "initial copy")
✔ klona
Benchmark:
JSON.stringify x 36,628 ops/sec ±1.34% (89 runs sampled)
fast-clone x 23,518 ops/sec ±1.18% (91 runs sampled)
lodash x 33,810 ops/sec ±1.34% (94 runs sampled)
rfdc x 181,634 ops/sec ±0.71% (95 runs sampled)
clone-deep x 84,558 ops/sec ±0.19% (96 runs sampled)
deep-copy x 112,866 ops/sec ±1.26% (94 runs sampled)
klona x 220,356 ops/sec ±0.34% (97 runs sampled)
Related
- dlv – safely read from deep properties in 120 bytes
- dset – safely write into deep properties in 160 bytes
- dequal – safely check for deep equality in 247 bytes
License
MIT © Luke Edwards